'use client';

import React, { createContext, useContext, useState, useEffect, ReactNode } from 'react';
import { isAuthenticated, getUserInfo, UserInfo, clearAuthData } from './authService';
import authApi from '../api/authApi';

// 认证上下文类型
interface AuthContextType {
  user: UserInfo | null;
  isAuthenticated: boolean;
  isLoading: boolean;
  login: (username: string, password: string) => Promise<void>;
  register: (username: string, email: string, password: string) => Promise<void>;
  logout: () => Promise<void>;
  refreshUser: () => Promise<void>;
}

// 创建认证上下文
const AuthContext = createContext<AuthContextType | undefined>(undefined);

// 认证上下文提供器组件的属性类型
interface AuthProviderProps {
  children: ReactNode;
}

// 认证上下文提供器组件
export const AuthProvider: React.FC<AuthProviderProps> = ({ children }) => {
  const [user, setUser] = useState<UserInfo | null>(null);
  const [isAuthenticatedState, setIsAuthenticatedState] = useState(false);
  const [isLoading, setIsLoading] = useState(true);

  // 初始化认证状态
  useEffect(() => {
    // 仅在客户端执行
    if (typeof window !== 'undefined') {
      const initializeAuth = async () => {
        try {
          setIsLoading(true);
          
          // 检查是否已登录
          const auth = isAuthenticated();
          setIsAuthenticatedState(auth);
          
          // 如果已登录，获取用户信息
          if (auth) {
            const userInfo = getUserInfo();
            setUser(userInfo);
            
            // 尝试刷新用户信息，确保数据最新
            try {
              const freshUserInfo = await authApi.getCurrentUser();
              setUser(freshUserInfo);
            } catch (error) {
              // 如果刷新失败，可能是token已过期，清除认证信息
              console.error('刷新用户信息失败:', error);
              handleLogout();
            }
          }
        } catch (error) {
          console.error('初始化认证状态失败:', error);
        } finally {
          setIsLoading(false);
        }
      };

      initializeAuth();
    }
  }, []);

  // 登录函数
  const login = async (username: string, password: string) => {
    try {
      setIsLoading(true);
      console.log('开始登录流程...');
      
      // 调用登录API
      const response = await authApi.login({ username, password });
      console.log('登录API调用成功，响应数据:', response);
      
      // 确保响应数据存在
      if (!response.data) {
        console.error('登录响应数据格式错误');
        throw new Error('登录响应数据不完整');
      }
      
      // 从响应中提取认证信息
      const { access_token, user } = response.data;
      
      // 确保用户数据存在
      if (!user) {
        console.error('登录响应中未包含用户信息');
        throw new Error('登录响应数据不完整');
      }
      
      // 构造token对象
      const tokenData = {
        access_token: access_token,
        refresh_token: '', // 响应中没有提供refresh_token
        expires_in: 3600 // 设置默认过期时间为1小时
      };
      
      // 保存认证信息
      if (typeof window !== 'undefined') {
        // 导入saveAuthData函数
        const { saveAuthData } = await import('./authService');
        saveAuthData(tokenData, user);
        
        // 更新状态
        setIsAuthenticatedState(true);
        setUser(user);
        
        // 执行客户端重定向，确保浏览器跳转到首页
        console.log('登录成功，执行客户端重定向到首页');
        window.location.href = '/';
      } else {
        // 在服务器端设置状态
        setIsAuthenticatedState(true);
        setUser(user);
      }
    } catch (error) {
      console.error('登录失败:', error);
      throw error;
    } finally {
      setIsLoading(false);
    }
  };

  // 注册函数
  const register = async (username: string, email: string, password: string) => {
    try {
      setIsLoading(true);
      const response = await authApi.register({ username, email, password });
      console.log('注册API调用成功，响应数据:', response);
      
      // 确保响应数据存在
      if (!response.data) {
        console.error('注册响应数据格式错误');
        throw new Error('注册响应数据不完整');
      }
      
      // 从响应中提取认证信息
      const { access_token, user } = response.data;
      
      // 确保用户数据存在
      if (!user) {
        console.error('注册响应中未包含用户信息');
        throw new Error('注册响应数据不完整');
      }
      
      // 构造token对象
      const tokenData = {
        access_token: access_token,
        refresh_token: '', // 响应中没有提供refresh_token
        expires_in: 3600 // 设置默认过期时间为1小时
      };
      
      // 保存认证信息
      if (typeof window !== 'undefined') {
        // 导入saveAuthData函数
        const { saveAuthData } = await import('./authService');
        saveAuthData(tokenData, user);
        
        // 更新状态
        setUser(user);
        setIsAuthenticatedState(true);
        
        // 注册成功后立即尝试重定向
        // 小延迟确保状态完全更新
        setTimeout(() => {
          window.location.href = '/';
        }, 100);
      } else {
        // 在服务器端设置状态
        setUser(user);
        setIsAuthenticatedState(true);
      }
    } catch (error) {
      console.error('注册失败:', error);
      throw error;
    } finally {
      setIsLoading(false);
    }
  };

  // 处理登出逻辑
  const handleLogout = () => {
    setUser(null);
    setIsAuthenticatedState(false);
    clearAuthData();
  };

  // 登出函数
  const logout = async () => {
    try {
      setIsLoading(true);
      await authApi.logout();
    } catch (error) {
      console.error('登出API调用失败:', error);
      // 即使API调用失败，仍然清除本地状态
    } finally {
      handleLogout();
      setIsLoading(false);
    }
  };

  // 刷新用户信息
  const refreshUser = async () => {
    try {
      setIsLoading(true);
      const freshUserInfo = await authApi.getCurrentUser();
      setUser(freshUserInfo);
    } catch (error) {
      console.error('刷新用户信息失败:', error);
      throw error;
    } finally {
      setIsLoading(false);
    }
  };

  // 提供认证上下文值
  const contextValue: AuthContextType = {
    user,
    isAuthenticated: isAuthenticatedState,
    isLoading,
    login,
    register,
    logout,
    refreshUser,
  };

  return (
    <AuthContext.Provider value={contextValue}>
      {children}
    </AuthContext.Provider>
  );
};

// 自定义Hook，用于在组件中访问认证上下文
export const useAuth = (): AuthContextType => {
  const context = useContext(AuthContext);
  if (context === undefined) {
    throw new Error('useAuth must be used within an AuthProvider');
  }
  return context;
};